const fs = require('fs');
const path = require('path');
const yaml = require('yaml');
const { program } = require('commander');
const Table = require('cli-table3');
const readline = require('readline').createInterface({
  input: process.stdin,
  output: process.stdout
});

// 定义有效的厂商列表
const validManufactures = ['xiaomi', 'hw', 'honor', 'oppo', 'vivo'];

// 配置命令行参数：移除 index，新增 name 为必填项
program
  .requiredOption('-n, --name <name>', '项目中文名（用于查询要更新的记录）') // 核心查询参数
  .option('-m, --manufacture <manufacture>', `厂商，必须是以下值之一: ${validManufactures.join(', ')}`)
  .option('-v, --version <version>', '版本号')
  .option('-b, --before <before>', '更改前体积')
  .option('-a, --after <after>', '更改后体积')
  .option('-l, --limit <limit>', '体积限制')
  .option('-c, --comment <comment>', '项目说明和描述（可选）');

// 解析命令行参数
program.parse(process.argv);
const options = program.opts();

// 读取记录文件
const yamlPath = path.join(__dirname, 'compresslist.yaml');
let records = [];

try {
  if (fs.existsSync(yamlPath)) {
    const yamlContent = fs.readFileSync(yamlPath, 'utf8');
    records = yaml.parse(yamlContent) || [];
  } else {
    console.log('没有找到记录文件，可能还没有任何记录。');
    readline.close();
    process.exit(0);
  }
} catch (error) {
  console.error('读取记录时出错：', error.message);
  readline.close();
  process.exit(1);
}

// 1. 按 name 筛选记录（精确匹配，避免模糊匹配误操作）
const matchedRecords = records.filter(record => record.name === options.name);

// 处理筛选结果
if (matchedRecords.length === 0) {
  console.error(`错误：未找到名称为「${options.name}」的记录`);
  readline.close();
  process.exit(1);
} else if (matchedRecords.length > 1) {
  // 2. 多条同名记录：让用户选择要更新的一条
  console.log(`找到 ${matchedRecords.length} 条名称为「${options.name}」的记录，请选择目标记录：`);

  // 展示同名记录列表（含关键信息，方便区分）
  const selectTable = new Table({
    head: ['序号', '厂商', '版本号', '更改后体积', '是否通过', '项目说明'],
    colWidths: [6, 10, 10, 12, 10, 30]
  });
  matchedRecords.forEach((record, idx) => {
    selectTable.push([
      idx + 1, // 序号从 1 开始（用户更易理解）
      record.manufacture,
      record.version,
      record.after,
      record.ispassed ? '是' : '否',
      record.comment || '无'
    ]);
  });
  console.log(selectTable.toString());

  // 接收用户选择的序号
  readline.question(`请输入要更新的记录序号（1-${matchedRecords.length}）：`, (answer) => {
    const selectIdx = parseInt(answer) - 1; // 转成数组索引（从 0 开始）
    if (isNaN(selectIdx) || selectIdx < 0 || selectIdx >= matchedRecords.length) {
      console.error('错误：无效的序号（请输入范围内的数字）');
      readline.close();
      process.exit(1);
    }
    // 找到目标记录在原数组中的索引（用于后续更新）
    const targetIndex = records.findIndex(item => item === matchedRecords[selectIdx]);
    readline.close();
    startUpdate(targetIndex); // 执行更新逻辑
  });
} else {
  // 3. 仅一条匹配记录：直接执行更新
  const targetIndex = records.findIndex(item => item === matchedRecords[0]);
  readline.close();
  startUpdate(targetIndex);
}

// 核心更新逻辑（复用原有验证和更新逻辑）
function startUpdate(targetIndex) {
  const targetRecord = records[targetIndex];
  const originalRecord = { ...targetRecord }; // 保存原始记录用于对比

  // 检查是否提供了至少一个更新字段
  const updateFields = ['name', 'manufacture', 'version', 'before', 'after', 'limit', 'comment'];
  const hasUpdateField = updateFields.some(field => options[field] !== undefined);
  if (!hasUpdateField) {
    console.error('错误：必须提供至少一个要更新的字段（-m/-v/-b/-a/-l/-c）');
    process.exit(1);
  }

  // 字段验证
  // 验证厂商合法性
  if (options.manufacture && !validManufactures.includes(options.manufacture)) {
    console.error(`错误：厂商必须是以下值之一: ${validManufactures.join(', ')}`);
    process.exit(1);
  }
  // 验证数字字段（before/after/limit）
  const numericFields = ['before', 'after', 'limit'];
  numericFields.forEach(field => {
    if (options[field] !== undefined && isNaN(Number(options[field]))) {
      console.error(`错误：${field} 必须是数字（如 683、323）`);
      process.exit(1);
    }
  });

  // 执行字段更新
  if (options.name !== undefined) targetRecord.name = options.name;
  if (options.manufacture !== undefined) targetRecord.manufacture = options.manufacture;
  if (options.version !== undefined) targetRecord.version = options.version;
  if (options.before !== undefined) targetRecord.before = Number(options.before);
  if (options.after !== undefined) targetRecord.after = Number(options.after);
  if (options.limit !== undefined) targetRecord.limit = Number(options.limit);
  if (options.comment !== undefined) targetRecord.comment = options.comment;

  // 重新计算是否通过（若 after/limit 有更新）
  if (options.after !== undefined || options.limit !== undefined) {
    targetRecord.ispassed = targetRecord.after <= targetRecord.limit;
  }

  // 展示更新前后对比
  console.log('\n更新前后对比：');
  const compareTable = new Table({
    head: ['字段', '更新前', '更新后'],
    colWidths: [15, 20, 20]
  });
  const displayFields = [
    { name: 'name', label: '项目名称' },
    { name: 'manufacture', label: '厂商' },
    { name: 'version', label: '版本号' },
    { name: 'before', label: '更改前体积' },
    { name: 'after', label: '更改后体积' },
    { name: 'limit', label: '体积限制' },
    { name: 'ispassed', label: '是否通过', formatter: v => v ? '是' : '否' },
    { name: 'comment', label: '项目说明', formatter: v => v || '无' }
  ];

  displayFields.forEach(field => {
    // 处理原始记录可能没有 comment 的兼容情况
    const originalVal = originalRecord[field.name] !== undefined
      ? (field.formatter ? field.formatter(originalRecord[field.name]) : originalRecord[field.name])
      : '无';
    const newVal = field.formatter
      ? field.formatter(targetRecord[field.name])
      : (targetRecord[field.name] || '无');

    // 只展示有变化的字段
    if (originalVal !== newVal) {
      compareTable.push([field.label, originalVal, newVal]);
    }
  });
  console.log(compareTable.toString());

  // 保存更新后的记录到 YAML 文件
  try {
    const yamlContent = yaml.stringify(records);
    fs.writeFileSync(yamlPath, yamlContent, 'utf8');
    console.log(`\n成功更新「${targetRecord.name}」的记录！`);
  } catch (error) {
    console.error('写入记录时出错：', error.message);
    process.exit(1);
  }
}